package com.neusoft.exercise;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 流程控制语句 Scanner 异常处理
 * 
 * @author LYW
 *
 */
public class HomeWorkControl {

	public static void main(String[] args) {

		// 判断是否为偶数
		// even();

		// 利润奖金
		// payBounsIf();

		// 分数出等级
		// outiGrade();

		// for循环求年薪
		 //sumSalary();

		// 猴子吃桃
		 //monkeyEatPeach();

		// 判断奇偶
		// evenOdd();

		// 数值判定
		// judgeNumber();

		// 整除
		// aliquotTest();

		// 闰年
		 //judgeLeapYear();

		// 加判断分数范围
		// outGradeIf();

		// 从小到大输出
		// min2Max1();

		// 拆分整数到个位数字输出
		// split();

		// 计算汇费
		// calculateTheCharge();

		// 用循环计算1-100间能被三整除的数值之和
		// 用for while do-while计算
		// sumOfDivide3();
		// 用公式计算
		// sumOfDivide31();

		// for 循环从0到9输出，遇5不输出
		// outputExcept5();

		// 递归求阶乘
		// recursive();
		// for循环求阶乘
		// forFactor();

		// 找出大于200的最小质数
		// findMinPrime();

		// 求反转整数方法1
		//splitReverse();
		//求反转整数方法2
		//reverseWithString();
		 //reverseArray();
		reverseArrWhile();
	}
	/**
	 * 17-4 数组方法 while
	 * 定义标志位
	 */
	private static void reverseArrWhile() {
		//定义数据变量
		long lNum = 90981234L;
		//定义反转数
		int turnNum=0;
		//定义标志位变量
		boolean maxBegin=false;
		//定义可以输入的位数
		//long最大整数为9,223,372,036,854,775,807
		//2的64次18，446，744，073，709，551，616
		int maxBits = 19;
		//定义索引
		int index=-1;
		//定义数组
		int[] arr = new int[maxBits];
		//因为一个整数的每位数据可能为0-9，所以赋值-1以区分
		//遍历给数组赋值
		for(int i=0;i<arr.length;i++) {
			arr[i]=-1;
			//输出这个数组
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		
		//while循环检查标志位
		while(maxBits>0) {
			
			//判断数据起始位
			if(lNum/(int)Math.pow(10, maxBits-1) != 0&& maxBegin ==false) {
				//如果出道10的i-1次幂时不为0 ，则标志找到数据的最高位
				maxBegin=true;
				index = maxBits;
				
			}
			//如果标志位为真，把每位数据存储在数组中
			if(maxBegin&& index!=-1) {
				arr[index-maxBits]=(int)lNum/(int)Math.pow(10, maxBits-1)%10;
			}
			//循环因子
			maxBits--;
		}
		
		
		//遍历循环输出
		
		for(int i=0;i<=index;i++) {
			System.out.print(arr[i]+" ");
			//计算反转数
			turnNum+=arr[i]*(int)Math.pow(10, i);
			
		}
		System.out.println();
		System.out.println("反转数为"+turnNum);	
		
		
	}
	
	
	
	
	/**
	 * 17-3数组的方法
	 * 定义索引
	 */
	private static void reverseArray() {
		System.out.println("程序开始请输入整数");
		//// 定义整型变量
		int iNumber=ScanInt();
		// 定义反转整数
		int iInversion=0;
		//定义标志为
		boolean bflag=false;
		//定义索引
		int index=0;
		
		// 定义一个整型数组
		int[] array10 = new int[10];
		//Arrays.fill(array10,-1);
		//for循环遍历输出
		System.out.println("\"=======for循环遍历输出1=====\"");
				for(int i=0;i<array10.length;i++) {
						array10[i]=-1;
						System.out.print(array10[i]+" ");
					
				}
				
		System.out.println();		
		// for循环计算数据分别存储到数组中
		for(int i=array10.length-1;i>0;i--) {
			if(iNumber/(int)Math.pow(10, i)!=0) {
			index=i;
			break;
			}
		}
		//for循环遍历输出
				System.out.println("=======for循环遍历输出2=====");
						for(int i=0;i<array10.length;i++) {
								array10[i]=-1;
								System.out.print(array10[i]+" ");
							
						}
						
				System.out.println();	
		
		//之前给index赋值的条件处没加强转，double算出的结果不等于0，所以index=9
//		for(int i=0;i<=index;i++)	{
//			array10[i]= iNumber/(int)Math.pow(10, index-i)%10;
//			System.out.println("array10["+i+"]="+array10[i]);
//		}
				System.out.println("index="+index);
				for(int i=0;i<array10.length;i++) {
					if(i<=index) {
						array10[i]= iNumber/(int)Math.pow(10, index-i)%10;
						System.out.println("array10["+i+"]="+array10[i]);
					}else {
						
						break;
					}
					
				}
		//for循环遍历输出
		System.out.println("=======for循环求反转数=====");
		for(int i=0;i<=index;i++) {
			iInversion +=array10[i] *  (int)Math.pow(10, i);
			
		}
		System.out.println(iInversion);
		System.out.println();	
		

	}
	
	
	
	
	
	
	

	/**
	 * 17-2
	 * 一个整数求反转整数 方法2：整数与字符串相互转换
	 */
	private static void reverseWithString() {
		// 定义整型变量
		int iNumber;
		// 定义反转整数
		int iInversion;
		// 定义一个字符串变量1
		String sInt2String = new String();
		// 定义字符串变量2
		String sString2Int;
		//定义退出变量
		String sexit;
		// while循环
		while (true) {
			// 提示信息1 while开始
			System.out.println("--程序开始运行");
			// 提示信息2 输入整数
			System.out.println("请输入一个整数");
			// 接收一个数据
			iNumber = ScanInt();
			{
				// 将这个整数转换成字符串
				sInt2String = Integer.toString(iNumber);
				// 输出这个字符串
				System.out.println("输入的整数的字符串为" + sInt2String);
				// 反转字符串
				sString2Int = new StringBuffer(sInt2String).reverse().toString();
				// 输出反转后的字符串
				System.out.println("反转后的字符串为" + sString2Int);
				// 将反转后的字符串赋给整数变量
				iInversion = Integer.valueOf(sString2Int).intValue();
				// 输出反转后的整数
				System.out.println(iNumber + "反转后为" + iInversion);
			}
			// 退出
			System.out.println("如果退出请输入exit，不退出请按任意键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				System.out.println("-----------------------------");
				break;
			} else {
				System.out.println("继续运行");
				System.out.println("-----------------------------");
			}
		}

	}

	/**
	 * 17-1
	 * 一个四位整数，求反向的整数 方法1:借用输入5位整数的拆分函数
	 */
	private static void splitReverse() {
		// 整数变量
		int iNumber = 0;
		int iInversion;
		// 接收退出的变量
		String sexit;
		// 存储每位上的数字
		int[] iplace = new int[4];

		//
		while (true) {
			// while循环开始
			System.out.println("--程序运行开始--");
			// 提示并输入
			System.out.println("请输入一个4位的正整数(1000-9999)");
			iNumber = ScanInt();
			// 如果输入数在范围内则执行程序，否则重新输入
			if (iNumber > 1000 && iNumber <= 9999) {
				// 定义一个中间变量存储数据并计算
				int itemp = iNumber;
				// 计算每位上存的数
				iplace[3] = itemp / 1000;
				itemp = itemp % 1000;
				iplace[2] = itemp / 100;
				itemp = itemp % 100;
				iplace[1] = itemp / 10;
				iplace[0] = itemp % 10;
				// 计算反转数
				iInversion = iplace[0] * 1000 + iplace[1] * 100 + iplace[2] * 10 + iplace[3];
				// 提示信息：
				System.out.println("整数" + iNumber + "翻转后为" + iInversion);

				// 判断程序是否退出
				System.out.println("如果退出请输入exit，不退出请按任意键并回车");
				sexit = scanStr();
				if (sexit.equals("exit")) {
					System.out.println("程序结束");
					break;
				} else {
					System.out.println("继续运行");
				}
			} else {
				// 如果数据不在1-99999范围内
				System.out.println("输入不在1000-9999范围内");
				// 开始新一轮while循环
				continue;
			}

		}

	}

	/**
	 * 16
	 * 找大于200的最小质数
	 */
	private static void findMinPrime() {
		// 定义一个存储200的数
		int iNumber;
		// 定义质数变量
		int iPrime;
		// 定义自增变量
		int iTemp;
		// 定义一个标志记录是否为质数 true为质数，false为合数
		boolean bflag;
		// 提示输入整数，并接收数据
		System.out.println("请输入一个整数，找出大于这个数的最小质数");
		iNumber = ScanInt();
		// 测试输入是否正确
		// System.out.println("iNumber=" + iNumber);
		// iNumber赋给中间变量
		iTemp = iNumber;
		// 测试赋值是否正确
		// System.out.println("iTemp=" + iTemp);
		while (true) {
			System.out.println("--while循环开始--");
			// 为新的数值充值标志为真，即默认这个数是质数
			bflag = true;
			// 质数的判断方法，循环2到数值的平方根的整数，如果能被整除为合数，都不能整除为质数
			for (int i = 2; i <= Math.sqrt(iTemp); i++) {
				if (iTemp % i == 0) {
					// 能被2-平方根内任意一个数整除，都不是质数
					// 修改标志为false ，此数非质数
					bflag = false;
					// 能被整除就直接跳出for循环，执行下面的语句
					break;
				}
			}
			// 如果标志位为false，则输出XX不是质数，重新开始新的一轮while循环
			// 如果标志位仍为true，则输出是大于XX的最小质数，并退出while循环，程序结束
			if (bflag == false) {
				System.out.println(iTemp + "不是质数");
				iTemp++;
				System.out.println("--while循环分支结束--");
				continue;
			} else if (bflag == true) {
				// 这句话多余，为了变量清晰，没有修改
				iPrime = iTemp;
				// 输出最小质数的信息
				System.out.println(iPrime + "是大于" + iNumber + "的最小质数");
				System.out.println("程序运行结束");
				// 退出while循环
				break;
			}
		}

	}

	/**
	 * 15-2
	 * for循环求阶乘
	 */
	private static void forFactor() {
		// 求阶乘的数
		int iNumber = 0;
		// 阶乘
		int iFactor = 1;
		// 退出
		String sexit;
		// 一直循环计算阶乘
		while (true) {
			// 提示输入
			System.out.println("请输入需要计算阶乘的正整数：");
			iNumber = ScanInt();
			// 每次循环重新初始化iFactor
			iFactor = 1;
			// 如果输入数为负数，跳出本轮循环
			if (iNumber < 0) {
				System.out.println("输入错误");
				continue;
			}
			if (iNumber == 0) {
				iFactor = 1;
			} else if (iNumber == 1) {
				iFactor = 1;
			} else if (iNumber >= 2) {

				for (int iTemp = iNumber; iTemp > 1; iTemp--) {
					iFactor *= iTemp;
					// 测试数据是否正确
					// System.out.println(iFactor);
				}
			}
			System.out.println(iNumber + "的阶乘为" + iFactor);
			// 退出
			// System.out.println("-----------------------------");
			System.out.println("如果退出请输入exit，不退出请按任意键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				System.out.println("-----------------------------");
				break;
			} else {
				System.out.println("继续运行");
				System.out.println("-----------------------------");
			}

		}

	}

	/**
	 * 15-1
	 * 递归求阶乘
	 */
	private static void recursive() {
		// 求阶乘的数
		int iNumber = 0;
		// 阶乘
		int iFactor;
		// 退出
		String sexit;
		// 一直循环计算阶乘
		while (true) {

			System.out.println("请输入需要计算阶乘的正整数：");
			iNumber = ScanInt();
			if (iNumber < 0) {
				System.out.println("输入错误");
				continue;
			}
			iFactor = factorial(iNumber);
			if (iFactor >= 1) {
				System.out.println(iNumber + "的阶乘为" + iFactor);

			} else if (iFactor == 0) {
				System.out.println("阶乘计算错误，请重新计算");
			}
			// 退出
			// System.out.println("-----------------------------");
			System.out.println("如果退出请输入exit，不退出请按任意键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				System.out.println("-----------------------------");
				break;
			} else {
				System.out.println("继续运行");
				System.out.println("-----------------------------");
			}

		}
	}

	/**
	 * 递归求阶乘的阶乘函数
	 * 
	 * @param iNumber
	 * @return iFactor 好像0的阶乘也是1？
	 */
	private static int factorial(int iNumber) {
		int iFactor = 1;
		if (iNumber > 1) {
			iFactor = iNumber * factorial(iNumber - 1);
		} else if (iNumber == 1) {
			iFactor = 1;
		} else if (iNumber == 0) {
			iFactor = 1;
		} else {
			iFactor = 0;
		}
		return iFactor;
	}

	/**
	 * 14
	 * for 循环从0到9输出，遇5不输出
	 */
	private static void outputExcept5() {
		for (int i = 0; i <= 90; i++) {
			if (i == 5) {
				continue;
			}
			System.out.println(i);
		}
	}

	/**
	 * 13-2
	 * 方法1 分别用for , while ,do while 循环 计算1-100之间能被3整除的数的和 手算方法 1-99 总值4950
	 * 相当于33行3个数，例如123 一行，97 98 99一行 设1/97一列 总值为a,2/98一列 总值a+33, 3/99一列，总值a+33+33
	 * 则a+a+33+a+33+33=4950 计算a+33+33 =1683
	 */
	private static void sumOfDivide31() {
		// 确定计算范围
		int iNumber;
		// 能被3整除的数的和
		int iSum3 = 0;
		// 从1到最后一个能整除3的数的和
		int iSumAll = 0;
		// 最大的能整除3的数
		int iTemp = 0;
		// 退出
		String sexit;

		// while
		while (true) {
			// 提示输入最大数
			System.out.println("计算从整数1到n范围内能被3整除的数的和，请输入n为：");
			iNumber = ScanInt();
			// 由于直接相连的三个书中肯定有一个能整除3，所以将输入数转换成最大的能被3整除的数
			if (iNumber % 3 == 0) {
				iTemp = iNumber;
			} else if (iNumber % 3 == 1) {
				iTemp = iNumber - 1;
			} else if (iNumber % 3 == 2) {
				iTemp = iNumber - 2;
			}

			// 计算从1到最后一个能整除3的数的和
			iSumAll = (1 + iTemp) * iTemp / 2;
			System.out.println(iSumAll);
			// 计算能被3整除的数的和
			iSum3 = (iSumAll - iTemp) / 3 + iTemp / 3 * 2;
			System.out.println("整数1-" + iNumber + "范围内能被3整除的数值之和为" + iSum3);

			// 退出
			System.out.println("-----------------------------");
			System.out.println("如果退出请输入exit，不退出请按任意键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				System.out.println("-----------------------------");
				break;
			} else {
				System.out.println("继续运行");
				System.out.println("-----------------------------");
			}

		}
	}

	/**
	 * 13-1
	 * 方法0 分别用for , while ,do while 循环 计算1-100之间能被3整除的数的和 手算方法 1-99 总值4950
	 * 相当于33行3个数，例如123 一行，97 98 99一行 设1/97一列 总值为a,2/98一列 总值a+33, 3/99一列，总值a+33+33
	 * 则a+a+33+a+33+33=4950 计算a+33+33 =1683
	 */
	private static void sumOfDivide3() {
		// 求和变量
		int iSum = 0;
		// 计数变量
		int i = 0;

		// for循环
		System.out.println("初始条件 i=" + i + " , iSum=" + iSum);
		for (i = 1; i <= 100; i++) {
			if (i % 3 == 0) {
				iSum += i;
			}
		}

		// 输出for循环下的计算结果
		System.out.println("通过for循环计算1-100间能被3整除的数值之和为" + iSum);
		System.out.println("=================================");

		// while
		i = 1;
		iSum = 0;
		System.out.println("初始条件 i=" + i + " , iSum=" + iSum);
		while (i <= 100) {
			if (i % 3 == 0) {
				iSum += i;
				i=i+3;
			}else {
			i++;
			}
		}
		System.out.println("通过while循环计算1-100间能被3整除的数值之和为" + iSum);
		System.out.println("=================================");

		// do-while
		i = 1;
		iSum = 0;
		System.out.println("初始条件 i=" + i + " , iSum=" + iSum);
		do {
			if (i % 3 == 0) {
				iSum += i;
				i=i+3;
			}else {
			i++;
			}
		} while (i <= 100);
		System.out.println("通过do-while循环计算1-100间能被3整除的数值之和为" + iSum);
		System.out.println("=================================");
	}

	/**
	 * 12
	 * 计算汇费<100--1,100-5000--1%，>5000--50
	 * 
	 */
	private static void calculateTheCharge() {
		// 汇款金额
		double iremittance;
		// 汇费
		double icharge = 0;

		// 输入一个数据
		System.out.println("请输入汇款金额：");
		iremittance = ScanInt();
		//
		if (iremittance < 100) {
			icharge = 1;

		} else if (iremittance >= 100 && iremittance < 5000) {
			icharge = iremittance * 0.01;
		} else if (iremittance >= 5000) {
			icharge = 50;
		}
		System.out.println("汇款" + iremittance + "元对应的汇费为" + icharge + "元");

	}
	
	
	
	
	

	/**
	 * 11
	 * 有一个不多于5位的正整数，求它是几位数 分别打印出每一位数字
	 */
	private static void split() {
		// 整数变量
		int inumber = 0;
		// 退出
		String sexit;
		// 存储每位上的数字
		int[] iplace = new int[5];
		// 存储了几位数
		int iNum = 0;
		//
		while (true) {
			// 提示并输入
			System.out.println("请输入一个至多5位的正整数(1-99999)");
			inumber = ScanInt();
			if (inumber > 0 && inumber <= 99999) {
				// 定义一个中间变量存储数据并计算
				int itemp = inumber;
				// 如果输入的数据为5位数，即首位除10000不为0
				if (itemp / 10000 != 0) {
					// 计算每位上存的数
					iplace[4] = itemp / 10000;
					itemp = inumber % 10000;
					iplace[3] = itemp / 1000;
					itemp = itemp % 1000;
					iplace[2] = itemp / 100;
					itemp = itemp % 100;
					iplace[1] = itemp / 10;
					iplace[0] = itemp % 10;
					// 确定这个数是5位数
					iNum = 5;

				} else if (itemp / 1000 != 0) {
					// 如果输入的数据为4位数，即首位除1000不为0
					// 计算每位上存的数
					iplace[3] = itemp / 1000;
					itemp = itemp % 1000;
					iplace[2] = itemp / 100;
					itemp = itemp % 100;
					iplace[1] = itemp / 10;
					iplace[0] = itemp % 10;
					// 确定这个数是4位数
					iNum = 4;

				} else if (itemp / 100 != 0) {
					// 如果输入的数据为3位数，即首位除100不为0
					// 计算每位上存的数
					iplace[2] = itemp / 100;
					itemp = itemp % 100;
					iplace[1] = itemp / 10;
					iplace[0] = itemp % 10;
					// 确定这个数是3位数
					iNum = 3;

				} else if (itemp / 10 != 0) {
					// 如果输入的数据为2位数，即首位除10不为0
					// 计算每位上存的数
					iplace[1] = itemp / 10;
					iplace[0] = itemp % 10;
					// 确定这个数是2位数
					iNum = 2;

				} else if (itemp % 10 != 0) {
					// 如果输入的数据为1位数
					// 计算每位上存的数
					iplace[0] = itemp % 10;
					// 确定这个数是1位数
					iNum = 1;

				}
				// 提示信息：
				System.out.println("输入的整数" + inumber +"为"+iNum+"位");
				System.out.println("输入的整数" + inumber + "各位数据为：");
				// for循环打印数组数据
				for (int i = iNum - 1; i >= 0; i--) {
					System.out.print(" " + iplace[i]);
				}
				System.out.println("如果退出请输入exit，不退出请按任意键并回车");
				sexit = scanStr();
				if (sexit.equals("exit")) {
					System.out.println("程序结束");
					break;
				} else {
					System.out.println("继续运行");
				}
			} else {
				// 如果数据不在1-99999范围内
				System.out.println("输入不在1-99999范围内");
				continue;
			}

		}

	}

	/**
	 * 10-2
	 * 输入三个整数，从小到大输出 
	 * 方法待改进 默认以 a b c输出，无论存什么数，经过方法运行后都已abc顺序输出	
	 * 排序算法没想明白 --待改
	 */
	private static void min2Max1() {
		// 定义三个数据输入
		int a;
		int b;
		int c;
		
		int max;
		int middle;
		int min;
		
		String sexit;

		// 加while循环
		while (true) {
			// 给三个变量赋值
			System.out.println("比较三个数的大小：");
			System.out.println("请输入第1个数：");
			a = ScanInt();
			System.out.println("请输入第2个数：");
			b = ScanInt();
			System.out.println("请输入第3个数：");
			c = ScanInt();
			int iMax=max(max(a,b),c);
			int iMiddle=0;
			int iMin=min(min(a,b),c);
			if(iMax!=a&&iMin!=a) {
				iMiddle=a;
			}else if(iMax!=b&&iMin!=b) {
				iMiddle=b;
			}else if(iMax!=c&&iMin!=c) {
				iMiddle=c;
			}
			
			
			System.out.println("三个数从小到大输出："+iMin+" < "+iMiddle+" < "+iMax);
			
			//退出
			System.out.println("如果退出请输入exit，不退出请按任意键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				break;
			} else {
				System.out.println("继续运行");
			}

		}
	}
	
	
	//寻找最大值
	private static int max(int a,int b) {
		int max;
		if(a>b) {
			max=a;
		}else {
			max=b;
		}
		return max;
	}
	//寻找最小值
	private static int min(int a,int b) {
		int min;
		if(a<b) {
			min=a;
		}else {
			min=b;
		}
		return min;
	}
	
	

	/**
	 * 10-1
	 * 输入三个整数，从小到大输出 方法待改进 如果a<b 交换a b 最后以a b c顺序输出
	 */
	private static void min2Max() {
		// 定义三个数据输入
		int iNumberX;
		int iNumberY;
		int iNumberZ;
		String sexit;

		// 加while循环
		while (true) {
			// 给三个变量赋值
			System.out.println("比较三个数的大小：");
			System.out.println("请输入第1个数：");
			iNumberX = ScanInt();
			System.out.println("请输入第2个数：");
			iNumberY = ScanInt();
			System.out.println("请输入第3个数：");
			iNumberZ = ScanInt();

			/*
			 * 判断方法 如果a>b，判断 b和c的关系 否 判断a和c a<b ,判断 b和c的关系 否 判断a和c
			 */

			if (iNumberX > iNumberY) {
				if (iNumberY > iNumberZ) {
					System.out.println("三个数排序为：" + iNumberZ + " " + iNumberY + " " + iNumberX);
				} else if (iNumberZ > iNumberX) {
					System.out.println("三个数排序为：" + iNumberY + " " + iNumberX + " " + iNumberZ);
				} else {
					System.out.println("三个数排序为：" + iNumberY + " " + iNumberZ + " " + iNumberX);

				}
			} else {
				if (iNumberX > iNumberZ) {
					System.out.println("三个数排序为：" + iNumberZ + " " + iNumberX + " " + iNumberY);
				} else if (iNumberZ > iNumberY) {
					System.out.println("三个数排序为：" + iNumberX + " " + iNumberY + " " + iNumberZ);
				} else {
					System.out.println("三个数排序为：" + iNumberZ + " " + iNumberX + " " + iNumberY);
				}
			}
			System.out.println("如果退出请输入exit，不退出请按任意键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				break;
			} else {
				System.out.println("继续运行");
			}

		}
	}

	/**
	 * 9
	 * outGrade()识别ScanInt
	 */
	private static void outGradeIf() {
		// 成绩变量
		int iScore;
		// 等级变量
		char iGrade;
		// 退出字符串
		String sexit;
		while (true) {
			// 输入成绩分数
			System.out.println("请输入待判定的分数(0-100)：");
			iScore = ScanInt();
			if (iScore > 0 && iScore <= 100) {
				;
			} else {
				continue;
			}
			// switch以成绩除10做判定条件
			// 判断成绩的等级
			switch (iScore / 10) {
			// 90-100分A
			case 10:
			case 9:
				iGrade = 'A';
				break;
			// 80-89分B
			case 8:
				iGrade = 'B';
				break;
			// 70-79分C
			case 7:
				iGrade = 'C';
				break;
			// 60-69分D
			case 6:
				iGrade = 'D';
				break;
			// 0-59分 E
			default:
				iGrade = 'E';
				break;
			}
			// 输出等级
			System.out.println("判定" + iScore + "分的等级为：" + iGrade + "级");
			System.out.println("如果退出请输入exit，不退出请按任意键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				break;
			} else {
				System.out.println("继续运行");
			}

		}
	}

	/**
	 * 8
	 * 循环输出一定范围内的闰年
	 */
	private static void judgeLeapYear() {
		// 起始年
		int iYear0;
		// 终止年
		int iYearn;
		// 定义一个中间变量
		int iYear;
		// 统计计算出的闰年个数
		int inum = 0;
		// 给两个变量赋值
		System.out.println("请输入待查询闰年的起始年份：");
		iYear0 = ScanInt();
		System.out.println("请输入待查询闰年的终止年份");
		iYearn = ScanInt();
		// 将初始年份赋给iYear
		iYear = iYear0;
		// 输出查询信息
		System.out.println("从" + iYear0 + "年到" + iYearn + "年查询闰年：");
		// 当iYear小于iYearn是一直循环
		while (iYear <= iYearn) {
			// 闰年的两个计算方法 1.整除100且整除400 如2000年
			if (iYear % 100 == 0 && iYear % 400 == 0) {
				inum++;
				iYear+=4;
				System.out.println(iYear + "年是闰年");
				// 2.不能整除100但能整除4的年份 如2004
			} else if (iYear % 100 != 0 && iYear % 4 == 0) {
				inum++;
				iYear+=4;
				System.out.println(iYear + "年是闰年");
			}else {
				
				// 自增，计算下一年，当iYear>iYearn成为循环结束条件
				iYear++;
			}

		}
		// 根据统计的闰年个数，如果计数为0 ，输出提示信息
		if (inum == 0) {
			System.out.println("从" + iYear0 + "年到" + iYearn + "年之间没有闰年");
		}

	}

	/**
	 * 7
	 * 被5和6整除
	 */
	private static void aliquotTest() {
		// 输入整数的变量
		int iNumber;
		// 退出变量
		String sexit;
		// 一直循环直至控制台输入exit退出
		while (true) {
			// 接收控制台数据 一个整数
			System.out.println("请输入一个整数：");
			iNumber = ScanInt();
			// 判断这个数据能否被5和6整除
			if (iNumber % 5 == 0 && iNumber % 6 == 0) {
				// 能被5/6同时整除输出
				System.out.println(iNumber + "能被5和6整除");
			} else if (iNumber % 5 == 0) {
				// 输出能被5整除
				System.out.println(iNumber + "能被5整除");
			} else if (iNumber % 6 == 0) {
				// 输出能被6整除
				System.out.println(iNumber + "能被6整除");
			} else {
				// 输出不能整除5/6
				System.out.println(iNumber + "不能被5和6整除");
			}
			// 输出提示信息，如果想退出就输入exit
			System.out.println("如果退出请输入exit，不退出请按任意字母键并回车");
			sexit = scanStr();
			// 如果控制台输入的是exit，就退出循环；否则继续运行
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				break;
			} else {
				System.out.println("继续运行");
			}

		}
	}

	/**
	 * 6
	 * 数值判定 判定输入的整数是否是1,3,5,是的话对应输出 不是则输出 x=none
	 */
	private static void judgeNumber() {
		// 定义输入的整数变量
		int iNumber;
		// 退出变量
		String sexit;
		while (true) {
			// 提示信息
			System.out.println("请输入一个整数：");
			// 扫描控制台输入
			iNumber = ScanInt();
			if (iNumber == 1) {
				System.out.println("x=1");
				// 如果数据和1相等 输出x=1
			} else if (iNumber == 3) {
				System.out.println("x=3");
				// 如果x不等于1，判断是不是等于3，如果是，输出x=3
			} else if (iNumber == 5) {
				System.out.println("x=5");
				// 如果x不等于1也不等于3，判断是不是等于5，是 ，输出x=5
			} else {
				System.out.println("x=none");
				// 如果以上条件都不满足，就输出x=none
			}
			// 询问用户是否想退出，判断sexit等于exit，退出；否则继续
			System.out.println("如果退出请输入exit，不退出请按任意字母键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				break;
			} else {
				System.out.println("继续运行");
			}

		}
	}

	/**
	 * 5
	 * 题目： 判断数的奇偶
	 * 
	 */
	private static void evenOdd() {
		// 定义一个变量接收控制台数据
		int iValue01;
		System.out.println("请输入一个整数：");
		iValue01 = ScanInt();
		// 偶数判断方法iValue01%2==0
		if (iValue01 % 2 == 0) {
			System.out.println("输入的数值" + iValue01 + "为偶数");
		} else {
			System.out.println("输入的数值" + iValue01 + "为奇数");
		}

	}

	/**
	 * 4
	 * // 猴子吃桃
	 * 
	 */
	private static void monkeyEatPeach() {
		// 桃子的数量
		int peach = 1;
		// 天数
		int iday = 10;

		// while从第十天递减到第一天，计算桃子数
		while (iday > 1) {
			peach = (peach + 1) * 2;
			iday--;
		}
		// 输出得到的结果
		System.out.println("猴子第一天采了" + peach + "只桃子");

	}

	/**
	 * 3
	 * 年薪增长求和 for
	 */
	private static void sumSalary() {
		// 定义年薪
		double iSalary = 30000;
		// 工资总和
		double iSum = iSalary;
		// for循环
		for (int i = 1; i < 10; i++) {
			// 第i年的年薪
			iSalary = iSalary * 1.06;
			// i年的总工资
			iSum += iSalary;
		}
		System.out.println("第十年工资为"+iSalary);
		System.out.println("十年总工资为" + iSum);

	}

	/**
	 * 2
	 * 根据分数输出等级
	 */
	private static void outiGrade() {
		// 成绩变量
		int iScore;
		// 等级变量
		char iGrade;
		// 退出字符串
		String sexit;
		while (true) {
			// 输入成绩分数
			System.out.println("请输入待判定的分数：");
			iScore = ScanInt();
			System.out.println(iScore);
			// switch以成绩除10做判定条件
			// 判断成绩的等级
			switch (iScore / 10) {
			// 90-100分A
			case 10:
			case 9:
				iGrade = 'A';
				break;
			// 80-89分B
			case 8:
				iGrade = 'B';
				break;
			// 70-79分C
			case 7:
				iGrade = 'C';
				break;
			// 60-69分D
			case 6:
				iGrade = 'D';
				break;
			// 0-59分 E
			default:
				iGrade = 'E';
				break;
			}
			// 输出等级
			System.out.println("判定" + iScore + "分的等级为：" + iGrade + "级");
			// 判定退出
			System.out.println("如果退出请输入exit，不退出请按任意键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				break;
			} else {
				System.out.println("继续运行");
			}

		}
	}

	/**
	 * 1
	 * 计算利润比例下的奖金
	 */
	private static void payBounsIf() {
		// 利润
		int profit;
		// 奖金
		double bouns;
		String sexit;
		while (true) {
			// 获取利润值
			profit = ScanInt();
			// if语句判断利润-奖金比例
			if (profit <= 10) {
				// 10万以内的奖金
				bouns = profit * 0.1;
			} else if (profit > 10 && profit <= 20) {
				// 10万-20万的奖金 为10*0.1，加上剩余部分*0.075
				bouns = 10 * 0.1 + (profit - 10) * 0.075;
			} else if (profit > 20 && profit <= 40) {
				// 类似
				bouns = 10 * 0.1 + (20 - 10) * 0.075 + (profit - 20) * 0.05;
			} else if (profit > 40 && profit <= 60) {
				bouns = 10 * 0.1 + (20 - 10) * 0.075 + (40 - 20) * 0.05 + (profit - 40) * 0.03;
			} else if (profit > 60 && profit <= 100) {
				bouns = 10 * 0.1 + (20 - 10) * 0.075 + (40 - 20) * 0.05 + (60 - 40) * 0.03 + (profit - 60) * 0.015;
			} else {
				bouns = 10 * 0.1 + (20 - 10) * 0.075 + (40 - 20) * 0.05 + (60 - 40) * 0.03 + (100 - 60) * 0.015
						+ (profit - 100) * 0.01;
			}
			System.out.println("当月奖金为" + bouns * 10000 + "元");
			// 判定退出
			System.out.println("如果退出请输入exit，不退出请按任意字母键并回车");
			sexit = scanStr();
			if (sexit.equals("exit")) {
				System.out.println("程序结束");
				break;
			} else {
				System.out.println("继续运行");
			}

		}
	}

	/**
	 * 题目： 假设有整型变量X，判断x是否为偶数 若为偶数，则在控制台上打印“输入的数值为偶数” 无论x是否为偶数，都在控制台上输出x的值
	 * 
	 */
	private static void even() {
		// 定义一个变量接收控制台数据
		int iValue01;
		iValue01 = ScanInt();
		// 偶数判断方法iValue01%2==0
		if (iValue01 % 2 == 0) {
			System.out.println("输入的数值" + iValue01 + "为偶数");
		}
		// 输出x的值
		System.out.println("x = " + iValue01);

	}

	/**
	 * 
	 */
	private static int ScanInt() {

		int iValue = 0;
		Scanner sc = new Scanner(System.in);
		// System.out.println("please input a number:");
		while (true) {
			try {
				iValue = sc.nextInt();
				// System.out.println("input="+iValue);
				break;
			} catch (Exception e) {
				System.out.println("输入错误，请重新输入：");
				sc.nextLine();
			}

		}
		return iValue;
	}

	/**
	 * 
	 */
	private static String scanStr() {

		String sValue;
		Scanner sc = new Scanner(System.in);
		System.out.println("please input:");
		while (true) {
			try {

				sValue = sc.nextLine();
				break;

			} catch (Exception e) {
				System.out.println("input again：");
				sc.nextLine();
			}

		}
		return sValue;
	}

	/**
	 * 
	 */

}
